const parser = require('@babel/parser');
const traverse = require('@babel/traverse').default;
const generate = require('@babel/generator').default;
const t = require('@babel/types');
const esprima = require("esprima")
const estraverse = require("estraverse")
const escodegen = require("escodegen")
const es_tool = require("../../tools/es_ast_tool")
const babel_tool = require('../../tools/babel_ast_tool');
const base_tool =  require('../../tools/base_ast_tools');
// const {renameFuncName} = require("../../tools/babel_ast_tool");
//
// // 解析代码
// const code = `
// var d = 32;
//
// function someFunc() {
//     var c = 100;
//     console.log(c);
//     A();
//     dd();
// }
//
// function A() {
//     function a(){
//      var c = dd();
//      var e  = dd.apply();
//     }
//     function dd() {
//        function a(){
//      var dd;
//     }
//         console.log(2);
//     }
//     dd();
// }
//
// function dd(g, f, ee) {
//     var b = dd;
//     console.log(dd);
//     return 1;
// }
//
// var g = dd;
// var c = dd(1, 2, 3);
// console.log(c);
// A();
// someFunc();
//
// function myMethod(){
//  console.log("f")
// }
//
//
// const myObject = {
//     // 这是对象的属性
//     myProperty: 'Hello, world!',
//
//     // 这是对象的内部函数（方法）
//     myMethod: function() {
//         console.log(this.myProperty); // 访问对象的属性
//         // 在这里可以执行其他操作
//     }
// };
//
// myObject.myMethod();
// myObject["myMethod"]();
//
// var b = "myMethod";
//
// var myProperty = 2;
// `;
// var ast = babel_tool.getAstByString(code);
// babel_tool.renameObjectMember(ast, "myMethod", "myMethod1");
//
// var ncode = babel_tool.genCodeByAst(ast);
// console.log(ncode)

// 将代码解析为 AST
// var ast = es_tool.getAstByString(code);
// const ast = parser.parse(code, { sourceType: 'module' });
// traverse(ast,{
//     FunctionDeclaration(path){
//         const { node } = path;
//         console.log(node.id.name);
//         if(node.id.name==="A"){
//             renameFuncName(node, "dd", "dd1");
//
//         }
//     }
// })
// estraverse.replace(ast,{
//     enter(node, parent){
//         if(node.type==="FunctionDeclaration"&&node.id.name==="A"){
//             var code1 = escodegen.generate(node);
//             var ast1 = babel_tool.getAstByString(code1);
//             babel_tool.renameFuncName(ast1, "dd","dd1");
//             // var code2 = babel_tool.genCodeByAst(ast1);
//             var new_node = base_tool.bableAstToEsAst(ast1);
//             // var code2 = escodegen.generate(new_node);
//             return new_node.body[0];
//             // console.log("code2:",code2.code);
//             // var funcs = es_tool.getFirstLevelFuncs(node);
//             // console.log(funcs);
//         }
//     }
// })

// var  code2 = es_tool.getCodeByAst(ast);
// console.log("code3:",code2);
// renameFuncName(ast, "dd", "dd1");

// var funcs = es_tool.getFirstLevelFuncs(ast);
// console.log(funcs);

//
// // 存储函数的重命名映射
// const functionRenameMap = new Map();
// let functionCounter = 0;
//
// // 生成唯一函数名
// function generateFunctionName() {
//     functionCounter += 1;
//     return String.fromCharCode(96 + functionCounter); // 从 'a' 开始
// }
//
// // 遍历 AST 并找到所有函数声明，重命名并处理重名
// traverse(ast, {
//     FunctionDeclaration(path) {
//         const { node } = path;
//
//         // 生成新的函数名
//         const newFunctionName = generateFunctionName();
//         const oldName = node.id.name;
//
//         // 更新函数名
//         node.id.name = newFunctionName;
//
//         // 存储重命名映射
//         functionRenameMap.set(oldName, newFunctionName);
//     },
//     Identifier(path) {
//         const { node } = path;
//
//         // 检查是否是函数的调用或使用
//         if (functionRenameMap.has(node.name)) {
//             const newName = functionRenameMap.get(node.name);
//             const binding = path.scope.getBinding(node.name);
//
//             // 确保只替换函数调用，保留变量名
//             if (binding && binding.kind === 'function') {
//                 node.name = newName;
//             }
//         }
//     }
// });
//
// // 处理函数调用和变量赋值
// traverse(ast, {
//     AssignmentExpression(path) {
//         const { left } = path.node;
//         if (t.isIdentifier(left) && functionRenameMap.has(left.name)) {
//             left.name = functionRenameMap.get(left.name);
//         }
//     }
// });

// 生成修改后的代码
// const output = generate(ast, {});
// 输出修改后的代码
// console.log(output.code);


// 尝试覆盖 String.prototype.toString（不推荐且不会工作）
var oldToString = String.prototype.toString;
String.prototype.toString = function() {
    console.log("Custom toString called!");
    return oldToString.call(this);
};

var oldIndexOf = String.prototype.indexOf;
String.prototype.indexOf = function(a,b) {
    // console.log("Custom indexOf called!");
    var result = oldIndexOf.call(this,a,b);
    if(a.substring(0,2)==="0x"||a===";"){
        console.log("myindexof;a="+a+"; b="+b+"; result="+result+"; src:"+this.substring(0,1000));
    }
    return result;
};

function a(){
    0x123,1299
}

// 创建一个新的字符串对象
const str = new String("Hello, world!");
var b = a+'';
b.indexOf("0x123");


// 尝试调用 toString 方法
console.log(str.toString()); // 这将不会输出 "Custom toString called!"，而是原始的字符串值 "Hello, world!"
console.log(b);

console.log(33>>> 0);
// 实际上，上面的代码会导致 TypeError，但某些环境（如浏览器控制台）可能会以某种方式绕过这个错误并显示原始行为

// // 正确的行为（但这不是覆盖，而是直接调用）
// String.prototype.customToString = function() {
//     return "Custom toString called!";
// };
//
// console.log(str.customToString()); // 输出 "Custom toString called!"

//定义hook add函数的代码

(function YvAVvnNNgz(){
    var add = function (Xp, d0) {
        return Xp + d0;
    };
})